package com.ruoyi.ldzlsb.service.impl;

import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Date;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import com.ruoyi.ldzlsb.domain.SbEquipmentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.ldzlsb.mapper.SbEquipmentTypeMapper;
import com.ruoyi.ldzlsb.service.ISbEquipmentTypeService;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.ldzlsb.service.ISbEquipmentService;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 设备类型Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-06-24
 */
@Service
public class SbEquipmentTypeServiceImpl implements ISbEquipmentTypeService 
{
    private static final Logger logger = LoggerFactory.getLogger(SbEquipmentTypeServiceImpl.class);

    @Autowired
    private SbEquipmentTypeMapper sbEquipmentTypeMapper;

    @Autowired
    private ISbEquipmentService sbEquipmentService;

    /**
     * 查询设备类型
     * 
     * @param typeId 设备类型主键
     * @return 设备类型
     */
    @Override
    public SbEquipmentType selectSbEquipmentTypeByTypeId(Long typeId)
    {
        return sbEquipmentTypeMapper.selectSbEquipmentTypeByTypeId(typeId);
    }

    /**
     * 查询设备类型列表
     * 
     * @param sbEquipmentType 设备类型
     * @return 设备类型
     */
    @Override
    public List<SbEquipmentType> selectSbEquipmentTypeList(SbEquipmentType sbEquipmentType)
    {
        return sbEquipmentTypeMapper.selectSbEquipmentTypeList(sbEquipmentType);
    }

    /**
     * 新增设备类型
     * 
     * @param sbEquipmentType 设备类型
     * @return 结果
     */
    @Override
    public int insertSbEquipmentType(SbEquipmentType sbEquipmentType)
    {
        // 添加调试信息
        logger.info("新增设备类型 - 原始数据: parentTypeId={}, typeSuperior={}", 
            sbEquipmentType.getParentTypeId(), sbEquipmentType.getTypeSuperior());
        
        // 如果没有指定类型编码，自动生成
        if (StringUtils.isEmpty(sbEquipmentType.getTypeCode())) {
            sbEquipmentType.setTypeCode(generateTypeCode());
        } else {
            // 如果用户提供了编码，检查是否已存在
            if (checkTypeCodeExists(sbEquipmentType.getTypeCode())) {
                throw new RuntimeException("类型编码 '" + sbEquipmentType.getTypeCode() + "' 已存在，请使用其他编码或留空由系统自动生成");
            }
        }
        
        // 处理父类型ID，确保parentTypeId和typeSuperior一致
        Long parentTypeId = sbEquipmentType.getParentTypeId();
        if (parentTypeId == null) {
            parentTypeId = sbEquipmentType.getTypeSuperior(); // 兼容旧字段
        }
        
        // 确保顶级父类的parentTypeId为null
        if (parentTypeId != null && parentTypeId == 0L) {
            parentTypeId = null;
        }
        
        // 同步两个父类型字段
        sbEquipmentType.setParentTypeId(parentTypeId);
        sbEquipmentType.setTypeSuperior(parentTypeId);
        
        logger.info("新增设备类型 - 处理后: parentTypeId={}, typeSuperior={}", 
            sbEquipmentType.getParentTypeId(), sbEquipmentType.getTypeSuperior());
        
        // 设置类型级别
        if (sbEquipmentType.getTypeLevel() == null) {
            if (parentTypeId == null) {
                // 如果没有父类型，设置为顶级(1级)
                sbEquipmentType.setTypeLevel(1);
            } else {
                // 有父类型，查询父类型获取其级别
                SbEquipmentType parentType = sbEquipmentTypeMapper.selectSbEquipmentTypeByTypeId(parentTypeId);
                if (parentType != null && parentType.getTypeLevel() != null) {
                    // 父级别+1
                    sbEquipmentType.setTypeLevel(parentType.getTypeLevel() + 1);
                } else {
                    // 默认设为2级
                    sbEquipmentType.setTypeLevel(2);
                }
            }
        }
        
        // 如果没有设置排序号，默认为0
        if (sbEquipmentType.getSortOrder() == null) {
            sbEquipmentType.setSortOrder(0);
        }
        
        // 如果没有设置状态，默认为启用(0)
        if (sbEquipmentType.getTypeStatus() == null) {
            sbEquipmentType.setTypeStatus("0");
        }
        
        // 如果没有设置删除标志，默认为未删除(0)
        if (sbEquipmentType.getEtDelete() == null) {
            sbEquipmentType.setEtDelete("0");
        }
        
        // 获取当前用户名作为createBy和updateBy
        String username = "admin";
        try {
            username = com.ruoyi.common.security.utils.SecurityUtils.getUsername();
        } catch (Exception e) {
            // 忽略异常，使用默认值
        }
        
        // 设置创建者和创建时间
        if (sbEquipmentType.getCreateBy() == null && sbEquipmentType.getEtFounder() == null) {
            sbEquipmentType.setCreateBy(username);
        }
        
        // 设置更新者
        sbEquipmentType.setUpdateBy(username);
        
        // 设置创建时间和更新时间
        Date now = new Date();
        if (sbEquipmentType.getCreateTime() == null && sbEquipmentType.getEtCreatedate() == null) {
        sbEquipmentType.setCreateTime(now);
        }
        
        // 设置更新时间
        sbEquipmentType.setUpdateTime(now);
        
        int result = sbEquipmentTypeMapper.insertSbEquipmentType(sbEquipmentType);
        logger.info("新增设备类型 - 插入结果: {}", result);
        
        return result;
    }

    /**
     * 修改设备类型
     * 
     * @param sbEquipmentType 设备类型
     * @return 结果
     */
    @Override
    public int updateSbEquipmentType(SbEquipmentType sbEquipmentType)
    {
        // 如果没有指定类型编码，自动生成
        if (StringUtils.isEmpty(sbEquipmentType.getTypeCode())) {
            sbEquipmentType.setTypeCode(generateTypeCode());
        } else {
            // 如果编码变更，检查是否已存在
            SbEquipmentType oldType = sbEquipmentTypeMapper.selectSbEquipmentTypeByTypeId(sbEquipmentType.getTypeId());
            if (oldType != null && !oldType.getTypeCode().equals(sbEquipmentType.getTypeCode())) {
                if (checkTypeCodeExists(sbEquipmentType.getTypeCode())) {
                    throw new RuntimeException("类型编码 '" + sbEquipmentType.getTypeCode() + "' 已存在，请使用其他编码");
                }
            }
        }
        
        // 获取并处理父类型ID
        Long parentTypeId = sbEquipmentType.getParentTypeId();
        if (parentTypeId == null) {
            parentTypeId = sbEquipmentType.getTypeSuperior(); // 兼容旧字段
        }
        
        // 确保顶级父类的parentTypeId为null
        if (parentTypeId != null && parentTypeId == 0L) {
            parentTypeId = null;
        }
        
        // 同步两个父类型字段
        sbEquipmentType.setParentTypeId(parentTypeId);
        sbEquipmentType.setTypeSuperior(parentTypeId);
        
        // 防止自己作为自己的父级
        if (parentTypeId != null && parentTypeId.equals(sbEquipmentType.getTypeId())) {
            throw new RuntimeException("设备类型不能设置自己作为父级");
        }
        
        // 防止子类型作为父级（循环引用）
        if (parentTypeId != null && isChildType(sbEquipmentType.getTypeId(), parentTypeId)) {
            throw new RuntimeException("不能将子类型设置为父级，这将导致循环引用");
        }
        
        // 检查父类型是否合理
        if (parentTypeId != null && sbEquipmentType.getTypeId() != null) {
            if (!isValidParentType(sbEquipmentType.getTypeId(), parentTypeId)) {
                throw new RuntimeException("设置的父类型不合理，可能导致循环引用或其他问题");
            }
            
            // 检查是否是顶级类型（ID为24）
            if (sbEquipmentType.getTypeId() == 24L && parentTypeId != 0L && parentTypeId != null) {
                throw new RuntimeException("顶级类型不能设置父类型");
            }
            
            // 设置正确的类型级别
            if (parentTypeId == 0L || parentTypeId == null) {
                // 顶级
                sbEquipmentType.setTypeLevel(1);
            } else {
                // 查找父类型
                SbEquipmentType parentType = sbEquipmentTypeMapper.selectSbEquipmentTypeByTypeId(parentTypeId);
                if (parentType != null && parentType.getTypeLevel() != null) {
                    sbEquipmentType.setTypeLevel(parentType.getTypeLevel() + 1);
                } else {
                    sbEquipmentType.setTypeLevel(2); // 默认为二级
                }
            }
        }
        
        // 设置更新时间
        sbEquipmentType.setUpdateTime(new Date());
        
        // 设置更新者，尝试从安全上下文获取，如果获取不到则使用默认值
        try {
            String username = com.ruoyi.common.security.utils.SecurityUtils.getUsername();
            if (StringUtils.isNotEmpty(username)) {
                sbEquipmentType.setUpdateBy(username);
            } else {
                sbEquipmentType.setUpdateBy("admin");
            }
        } catch (Exception e) {
            // 如果获取当前用户失败，设置默认更新者为admin
            sbEquipmentType.setUpdateBy("admin");
        }
        
        return sbEquipmentTypeMapper.updateSbEquipmentType(sbEquipmentType);
    }

    /**
     * 批量删除设备类型
     * 
     * @param typeIds 需要删除的设备类型主键
     * @return 结果
     */
    @Override
    public int deleteSbEquipmentTypeByTypeIds(Long[] typeIds)
    {
        int result = 0;
        for (Long typeId : typeIds) {
            // 对每个类型ID执行删除操作
            result += deleteSbEquipmentTypeByTypeId(typeId);
        }
        return result;
    }

    /**
     * 删除设备类型信息
     * 
     * @param typeId 设备类型主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSbEquipmentTypeByTypeId(Long typeId)
    {
        // 检查是否可以删除
        Map<String, Object> checkResult = this.checkCanDelete(typeId);
        if ((boolean) checkResult.getOrDefault("canDelete", false) || checkResult.containsKey("needConfirm")) {
            // 如果可以删除或者需要确认并且前端已确认
            // 1. 删除关联的设备（如果存在）
            int equipmentCount = (int) checkResult.getOrDefault("equipmentCount", 0);
            if (equipmentCount > 0) {
                // 调用设备服务删除设备
                sbEquipmentService.deleteSbEquipmentByTypeId(typeId);
            }
            
            // 2. 删除当前设备类型
            return sbEquipmentTypeMapper.deleteSbEquipmentTypeByTypeId(typeId);
        }
        return 0;
    }
    
    /**
     * 获取设备类型树形结构
     * 
     * @return 设备类型树形数据
     */
    @Override
    public List<Map<String, Object>> getEquipmentTypeTree() {
        // 查询所有设备类型
        SbEquipmentType query = new SbEquipmentType();
        query.setIsDelete("0"); // 只查询未删除的
        List<SbEquipmentType> typeList = sbEquipmentTypeMapper.selectSbEquipmentTypeList(query);
        
        // 构建树形结构
        List<Map<String, Object>> treeList = new ArrayList<>();
        Map<Long, Map<String, Object>> nodeMap = new HashMap<>();
        
        // 先将所有节点存入map，并构建没有children的节点
        for (SbEquipmentType type : typeList) {
            Map<String, Object> node = new HashMap<>();
            node.put("id", type.getTypeId()); // 添加id字段，用于el-cascader的value
            node.put("label", type.getTypeName()); // 添加label字段，用于el-cascader的显示
            node.put("typeId", type.getTypeId());
            node.put("typeCode", type.getTypeCode());
            node.put("typeName", type.getTypeName());
            node.put("parentTypeId", type.getParentTypeId());
            node.put("typeLevel", type.getTypeLevel());
            node.put("sortOrder", type.getSortOrder());
            node.put("typeStatus", type.getTypeStatus());
            node.put("remark", type.getRemark());
            node.put("children", new ArrayList<Map<String, Object>>());
            nodeMap.put(type.getTypeId(), node);
        }
        
        // 构建树形结构
        for (SbEquipmentType type : typeList) {
            Map<String, Object> node = nodeMap.get(type.getTypeId());
            if (type.getParentTypeId() == null || type.getParentTypeId() == 0) {
                // 根节点
                treeList.add(node);
            } else {
                // 子节点
                Map<String, Object> parentNode = nodeMap.get(type.getParentTypeId());
                if (parentNode != null) {
                    List<Map<String, Object>> children = (List<Map<String, Object>>) parentNode.get("children");
                    children.add(node);
                } else {
                    // 如果父节点不存在，则作为根节点
                    treeList.add(node);
                }
            }
        }
        
        // 递归处理子节点的排序
        sortTreeNodes(treeList);
        
        return treeList;
    }
    
    /**
     * 递归排序树节点
     * 
     * @param nodes 节点列表
     */
    private void sortTreeNodes(List<Map<String, Object>> nodes) {
        // 按照排序序号进行排序
        nodes.sort((a, b) -> {
            Integer sortA = (Integer) a.get("sortOrder");
            Integer sortB = (Integer) b.get("sortOrder");
            return sortA == null ? -1 : (sortB == null ? 1 : sortA.compareTo(sortB));
        });
        
        // 递归排序子节点
        for (Map<String, Object> node : nodes) {
            List<Map<String, Object>> children = (List<Map<String, Object>>) node.get("children");
            if (children != null && !children.isEmpty()) {
                sortTreeNodes(children);
            }
        }
    }
    
    /**
     * 检查设备类型编码是否已存在
     * 
     * @param typeCode 设备类型编码
     * @return 结果
     */
    @Override
    public boolean checkTypeCodeExists(String typeCode)
    {
        return sbEquipmentTypeMapper.checkTypeCodeUnique(typeCode) > 0;
    }
    
    /**
     * 检查设备类型编码是否已存在（排除当前ID）
     * 
     * @param typeCode 设备类型编码
     * @param typeId 当前设备类型ID
     * @return 结果
     */
    @Override
    public boolean checkTypeCodeExistsExcludeSelf(String typeCode, Long typeId)
    {
        return sbEquipmentTypeMapper.checkTypeCodeUniqueExcludeSelf(typeCode, typeId) > 0;
    }
    
    /**
     * 生成设备类型编码
     * 
     * @return 设备类型编码
     */
    @Override
    public String generateTypeCode()
    {
        // 获取当前日期时间
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        String dateStr = now.format(formatter);
        
        // 基本前缀 - 使用默认值EQT
        String prefix = "EQT";
        
        // 日期部分
        String datePart = dateStr;
        
        // 使用更随机的方法生成后缀
        // 结合当前时间戳、纳秒和随机数
        long timestamp = System.currentTimeMillis();
        long nanoTime = System.nanoTime();
        int randomNum = new java.util.Random().nextInt(1000);
        
        // 组合多个随机源
        String randomSuffix = String.format("%03d", (timestamp + nanoTime + randomNum) % 1000);
        
        // 组合生成新编码
        String newCode = prefix + datePart + randomSuffix;
        
        // 验证编码是否已存在，如果存在则重新生成
        int retryCount = 0;
        while (checkTypeCodeExists(newCode) && retryCount < 10) {
            retryCount++;
            // 增加更多随机性
            timestamp = System.currentTimeMillis();
            nanoTime = System.nanoTime();
            randomNum = new java.util.Random().nextInt(1000);
            randomSuffix = String.format("%03d", (timestamp + nanoTime + randomNum) % 1000);
            newCode = prefix + datePart + randomSuffix;
            
            try {
                Thread.sleep(1); // 短暂等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        
        // 如果还是重复，使用时间戳作为后缀
        if (checkTypeCodeExists(newCode)) {
            newCode = prefix + datePart + String.format("%04d", timestamp % 10000);
        }
        
        return newCode;
    }
    
    /**
     * 根据类型名称生成编码
     * 
     * @param typeName 类型名称
     * @return 生成的类型编码
     */
    @Override
    public String generateTypeCodeFromName(String typeName) {
        if (StringUtils.isEmpty(typeName)) {
            return generateTypeCode(); // 如果没有提供类型名称，使用默认生成方法
        }
        
        // 提取名称中的首个有效字符作为前缀
        String prefix = "EQ"; // 默认前缀
        
        // 提取第一个字符
        if (typeName.length() > 0) {
            char firstChar = typeName.charAt(0);
            
            // 如果是英文字母，直接使用大写形式
            if (Character.isLetter(firstChar)) {
                prefix = String.valueOf(Character.toUpperCase(firstChar));
            }
            // 如果是中文，使用EQ前缀
            // 这里可以扩展为使用中文首字拼音首字母，但需要引入额外的拼音转换库
        }
        
        // 获取当前日期时间
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyMMdd");
        String dateStr = now.format(formatter);
        
        // 使用更随机的方法生成后缀
        long timestamp = System.currentTimeMillis();
        long nanoTime = System.nanoTime();
        int randomNum = new java.util.Random().nextInt(1000);
        String randomPart = String.format("%03d", (timestamp + nanoTime + randomNum) % 1000);
        
        // 组合编码：前缀 + 日期 + 随机数
        String code = prefix + dateStr + randomPart;
        
        // 检查编码是否已存在，如果存在则重新生成
        int retryCount = 0;
        while (checkTypeCodeExists(code) && retryCount < 10) {
            retryCount++;
            // 增加更多随机性
            timestamp = System.currentTimeMillis();
            nanoTime = System.nanoTime();
            randomNum = new java.util.Random().nextInt(1000);
            randomPart = String.format("%03d", (timestamp + nanoTime + randomNum) % 1000);
            code = prefix + dateStr + randomPart;
            
            try {
                Thread.sleep(1); // 短暂等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        
        // 如果还是重复，使用时间戳作为后缀
        if (checkTypeCodeExists(code)) {
            code = prefix + dateStr + String.format("%04d", timestamp % 10000);
        }
        
        return code;
    }

    /**
     * 更新设备类型状态
     * 
     * @param sbEquipmentType 设备类型
     * @return 结果
     */
    @Override
    public int updateSbEquipmentTypeStatus(SbEquipmentType sbEquipmentType)
    {
        SbEquipmentType updateType = new SbEquipmentType();
        updateType.setTypeId(sbEquipmentType.getTypeId());
        updateType.setTypeStatus(sbEquipmentType.getTypeStatus());
        updateType.setUpdateTime(new Date());
        
        // 设置更新者，尝试从安全上下文获取，如果获取不到则使用默认值
        try {
            String username = com.ruoyi.common.security.utils.SecurityUtils.getUsername();
            if (StringUtils.isNotEmpty(username)) {
                updateType.setUpdateBy(username);
            } else {
                updateType.setUpdateBy("admin");
            }
        } catch (Exception e) {
            // 如果获取当前用户失败，设置默认更新者为admin
            updateType.setUpdateBy("admin");
        }
        
        // 直接调用Mapper执行更新状态的SQL，避免触发循环引用检查
        return sbEquipmentTypeMapper.updateSbEquipmentTypeStatus(updateType);
    }
    
    /**
     * 检查设备类型是否可以删除
     * 
     * @param typeId 设备类型ID
     * @return 检查结果（包含是否可删除、设备数量等信息）
     */
    @Override
    public Map<String, Object> checkCanDelete(Long typeId)
    {
        Map<String, Object> result = new HashMap<>();
        
        // 检查是否是顶级父级类型（ID为24的"设备类型"）
        if (typeId != null && typeId == 24L) {
            result.put("canDelete", false);
            result.put("reason", "顶级设备类型不能删除");
            return result;
        }
        
        // 检查是否有子类型
        int childCount = sbEquipmentTypeMapper.selectChildCountByParentId(typeId);
        if (childCount > 0) {
            result.put("canDelete", false);
            result.put("reason", "该类型下还有" + childCount + "个子类型，不能删除");
            result.put("childCount", childCount);
            return result;
        }
        
        // 检查是否有关联的设备（不管是什么状态）
        int equipmentCount = sbEquipmentTypeMapper.selectEquipmentCountByTypeId(typeId);
        if (equipmentCount > 0) {
            result.put("canDelete", false);
            result.put("reason", "该类型下还有" + equipmentCount + "台设备，不能删除");
            result.put("equipmentCount", equipmentCount);
            return result;
        }
        
        // 没有子类型和设备，可以删除
        result.put("canDelete", true);
        
        return result;
    }

/**
 * 检查设置的父类型是否合理
 * 
 * @param typeId 当前类型ID
 * @param parentTypeId 父类型ID
 * @return 检查结果，true表示合理，false表示不合理
 */
private boolean isValidParentType(Long typeId, Long parentTypeId) {
    // 如果父类型ID为空或为0，表示是顶级节点，直接返回true
    if (parentTypeId == null || parentTypeId == 0) {
        return true;
    }
    
    // 如果父类型ID等于当前类型ID，表示不合理（不能成为自己的父类型）
    if (parentTypeId.equals(typeId)) {
        return false;
    }
    
    // 检查是否形成循环引用：判断当前类型是否已经是目标父类型的某级父类型
    return !isChildType(parentTypeId, typeId);
}

/**
 * 递归检查一个类型是否是另一个类型的子类型
 * 
 * @param typeId 要检查的类型ID
 * @param potentialParentId 潜在的父类型ID
 * @return true表示是子类型，false表示不是
 */
private boolean isChildType(Long typeId, Long potentialParentId) {
    // 如果类型ID为空，则返回false
    if (typeId == null) {
        return false;
    }
    
    // 查询当前类型的父类型
    SbEquipmentType currentType = sbEquipmentTypeMapper.selectSbEquipmentTypeByTypeId(typeId);
    if (currentType == null) {
        return false;
    }
    
    Long currentParentId = currentType.getParentTypeId();
    
    // 如果当前类型的父ID等于潜在父类型ID，则说明形成循环
    if (potentialParentId.equals(currentParentId)) {
        return true;
    }
    
    // 如果父类型ID为空或为0，则说明到达顶层，不会形成循环
    if (currentParentId == null || currentParentId == 0) {
        return false;
    }
    
    // 递归检查父类型
    return isChildType(currentParentId, potentialParentId);
    }

    /**
     * 根据父类型ID查询子类型列表
     * 
     * @param parentId 父类型ID
     * @return 子类型列表
     */
    @Override
    public List<SbEquipmentType> selectChildTypesByParentId(Long parentId) 
    {
        SbEquipmentType query = new SbEquipmentType();
        query.setParentTypeId(parentId);
        query.setIsDelete("0"); // 只查询未删除的子类型
        return sbEquipmentTypeMapper.selectSbEquipmentTypeList(query);
    }

/**
 * 检查设备类型是否可以停用
 * 1. 检查是否有非报废状态的设备
 * 2. 检查是否有启用状态的子类型
 * 
 * @param typeId 设备类型ID
 * @return 检查结果，包含是否可以停用、原因等信息
 */
@Override
public Map<String, Object> checkCanDisable(Long typeId) {
    Map<String, Object> result = new HashMap<>();
    
    // 1. 检查是否有非报废状态的设备
    int nonScrapCount = countNonScrapEquipmentByTypeId(typeId);
    if (nonScrapCount > 0) {
        result.put("canDisable", false);
        result.put("reason", "该类型下还有" + nonScrapCount + "台非报废状态的设备，不能停用");
        result.put("nonScrapCount", nonScrapCount);
        return result;
    }
    
    // 2. 检查是否有启用状态的子类型
    List<SbEquipmentType> childTypes = selectChildTypesByParentId(typeId);
    List<SbEquipmentType> activeChildTypes = new ArrayList<>();
    for (SbEquipmentType child : childTypes) {
        if ("0".equals(child.getTypeStatus())) {
            activeChildTypes.add(child);
        }
    }
    
    if (!activeChildTypes.isEmpty()) {
        result.put("canDisable", false);
        result.put("reason", "该类型下还有" + activeChildTypes.size() + "个子类型处于启用状态，请先停用所有子类型");
        result.put("activeChildCount", activeChildTypes.size());
        return result;
    }
    
    // 可以停用
    result.put("canDisable", true);
    return result;
}

/**
 * 检查设备类型下是否有非报废状态的设备
 * 
 * @param typeId 设备类型ID
 * @return 非报废设备数量
 */
@Override
public int countNonScrapEquipmentByTypeId(Long typeId) {
    return sbEquipmentTypeMapper.selectNonScrapEquipmentCountByTypeId(typeId);
}

/**
 * 检查设备类型下是否有报废状态的设备
 * 
 * @param typeId 设备类型ID
 * @return 报废设备数量
 */
@Override
public int countScrapEquipmentByTypeId(Long typeId) {
    return sbEquipmentTypeMapper.selectScrapEquipmentCountByTypeId(typeId);
    }
}
